/*
 * @Date         : 2022-09-08 09:11:36
 * @LastEditTime : 2023-07-13 09:44:30
 * @LastEditors  : Please set LastEditors
 * @Description  :
 * @FilePath     : \main_board\SRC\USER_APP\myQueue.c
 * @FileLog      :
 */
#include "myQueue.h"

/* 定义队列数据类型 */
queueType queueData[QUEUE_SIZE];
QUEUE_T queue;
extern void protocol_send_reg(u8 mcode, 
                              u16 regAddr0, u8 regNum0,
                              u16 regAddr1, u8 regNum1,
                              u16 regAddr2, u8 regNum2,
                              u16 regAddr3, u8 regNum3,
                              u16 regAddr4, u8 regNum4,
                              u16 regAddr5, u8 regNum5,
                              u16 regAddr6, u8 regNum6,
                              u16 regAddr7, u8 regNum7,
                              u16 regAddr8, u8 regNum8,
                              u16 regAddr9, u8 regNum9,
                              u8 ptrNum);

void my_queue_init(void)
{
    u16 i = 0;

    for(i=0;i<QUEUE_SIZE;i++)
    {
        queueData[i].mcode = 0;
        queueData[i].reg[0].regAddr = 0;
        queueData[i].reg[0].regNum = 0;
        queueData[i].reg[1].regAddr = 0;
        queueData[i].reg[1].regNum = 0;
        queueData[i].reg[2].regAddr = 0;
        queueData[i].reg[2].regNum = 0;
        queueData[i].reg[3].regAddr = 0;
        queueData[i].reg[3].regNum = 0;
        queueData[i].reg[4].regAddr = 0;
        queueData[i].reg[4].regNum = 0;
        queueData[i].reg[5].regAddr = 0;
        queueData[i].reg[5].regNum = 0;
        queueData[i].reg[6].regAddr = 0;
        queueData[i].reg[6].regNum = 0;
        queueData[i].reg[7].regAddr = 0;
        queueData[i].reg[7].regNum = 0;
        queueData[i].reg[8].regAddr = 0;
        queueData[i].reg[8].regNum = 0;
        queueData[i].reg[9].regAddr = 0;
        queueData[i].reg[9].regNum = 0;
        queueData[i].mcode = 0;
    }
    queue_Init(&queue, queueData, sizeof(queueData[0]), QUEUE_SIZE);
}

void my_queue_enqueue(u8 mcode,
                       u16 regAddr0, u8 regNum0,
                       u16 regAddr1, u8 regNum1,
                       u16 regAddr2, u8 regNum2,
                       u16 regAddr3, u8 regNum3,
                       u16 regAddr4, u8 regNum4,
                       u16 regAddr5, u8 regNum5,
                       u16 regAddr6, u8 regNum6,
                       u16 regAddr7, u8 regNum7,
                       u16 regAddr8, u8 regNum8,
                       u16 regAddr9, u8 regNum9,
                       u8 ptrNum)
{
    queueType sQueueData;

    sQueueData.mcode = mcode;
    sQueueData.reg[0].regAddr = regAddr0;
    sQueueData.reg[0].regNum = regNum0;
    sQueueData.reg[1].regAddr = regAddr1;
    sQueueData.reg[1].regNum = regNum1;
    sQueueData.reg[2].regAddr = regAddr2;
    sQueueData.reg[2].regNum = regNum2;
    sQueueData.reg[3].regAddr = regAddr3;
    sQueueData.reg[3].regNum = regNum3;
    sQueueData.reg[4].regAddr = regAddr4;
    sQueueData.reg[4].regNum = regNum4;
    sQueueData.reg[5].regAddr = regAddr5;
    sQueueData.reg[5].regNum = regNum5;
    sQueueData.reg[6].regAddr = regAddr6;
    sQueueData.reg[6].regNum = regNum6;
    sQueueData.reg[7].regAddr = regAddr7;
    sQueueData.reg[7].regNum = regNum7;
    sQueueData.reg[8].regAddr = regAddr8;
    sQueueData.reg[8].regNum = regNum8;
    sQueueData.reg[9].regAddr = regAddr9;
    sQueueData.reg[9].regNum = regNum9;
    sQueueData.ptrNum = ptrNum;
    if(queue_GetItemCount(&queue) > QUEUE_SIZE)
    {
        ;/* 队列已满 */
    }
    queue_Enqueue(&queue,&sQueueData);
}

void my_queue_dequeue(void)
{
    queueType ssQueueData;
    u16 ItemCount = 0;

    ItemCount = queue_GetItemCount(&queue);
    
    if(!ItemCount)
    {
        return;
    }
   // printf("ItemCount is %d\r\n",ItemCount);

    queue_Dequeue(&queue, &ssQueueData);
    protocol_send_reg(
        ssQueueData.mcode,
        ssQueueData.reg[0].regAddr,
        ssQueueData.reg[0].regNum,
        ssQueueData.reg[1].regAddr,
        ssQueueData.reg[1].regNum,
        ssQueueData.reg[2].regAddr,
        ssQueueData.reg[2].regNum,
        ssQueueData.reg[3].regAddr,
        ssQueueData.reg[3].regNum,
        ssQueueData.reg[4].regAddr,
        ssQueueData.reg[4].regNum,
        ssQueueData.reg[5].regAddr,
        ssQueueData.reg[5].regNum,
        ssQueueData.reg[6].regAddr,
        ssQueueData.reg[6].regNum,
        ssQueueData.reg[7].regAddr,
        ssQueueData.reg[7].regNum,
        ssQueueData.reg[8].regAddr,
        ssQueueData.reg[8].regNum,
        ssQueueData.reg[9].regAddr,
        ssQueueData.reg[9].regNum,
        ssQueueData.ptrNum);
}

/* *****************************************上方为用户自定义队列代码，可根据使用场景修改**************************************** */
/* *****************************************下方为队列数据结构源码，不可修改*************************************************** */


/**
 * @start: **************************************************************
 * @author: chufengsen
 * @functhion:  
 * @description: 
 * @param {QUEUE_T} *pQueue
 * @param {void} *pBuffer
 * @param {BYTE} sizeOfElements
 * @param {BYTE} numberOfElements
 * @return {*}
 * @end: ****************************************************************
 */
void queue_Init(QUEUE_T *pQueue, void *pBuffer, BYTE sizeOfElements, BYTE numberOfElements)
{
    pQueue->out  = 0;
    pQueue->in = 0;
    pQueue->queueSize = numberOfElements;
    pQueue->count = 0;
    pQueue->elementType = sizeOfElements;
    pQueue->array = (BYTE *)pBuffer;
}
/**
 * @start: **************************************************************
 * @author: chufengsen
 * @functhion:  
 * @description: 
 * @param {QUEUE_T} *pQueue
 * @param {void} *pElement
 * @return {*}
 * @end: ****************************************************************
 */
BOOL queue_Enqueue(QUEUE_T *pQueue, void *pElement)
{
    {
        BYTE i;
        BYTE *pEl = pElement;

        for (i = 0; i < pQueue->elementType; i++)
        {
            pQueue->array[(pQueue->in) * (pQueue->elementType) + i] = *(pEl + i);
        }

        pQueue->in = (pQueue->in + 1) % pQueue->queueSize;
        pQueue->count = pQueue->count + 1;
    }
    return TRUE;
}
/**
 * @start: **************************************************************
 * @author: chufengsen
 * @functhion:  
 * @description: 
 * @param {QUEUE_T} *pQueue
 * @param {void} *pElement
 * @return {*}
 * @end: ****************************************************************
 */
BOOL queue_Dequeue(QUEUE_T *pQueue, void *pElement)
{
    if (pQueue->count <= 0)
    {
        return FALSE;
    }
    else
    {
        BYTE i;
        BYTE *pEl = pElement;

        for (i = 0; i < pQueue->elementType; i++)
        {
            *(pEl + i) = pQueue->array[(pQueue->out) * (pQueue->elementType) + i];
        }

        pQueue->out = (pQueue->out + 1) % pQueue->queueSize;
        pQueue->count = pQueue->count - 1;
    }
    return TRUE;
}
/**
 * @start: **************************************************************
 * @author: chufengsen
 * @functhion:  
 * @description: 
 * @param {QUEUE_T} *pQueue
 * @return {*}
 * @end: ****************************************************************
 */
u8 queue_GetItemCount(QUEUE_T *pQueue)
{
    return pQueue->count;
}
